1 Introduction

1.1 C’est quoi R ?

  • R est un langage dérivé du langage S, interprété (en opposition aux langages compilés), non typé.
  • R est un logiciel libre (sous licence GNU GPL), gratuit, multiplateforme.
  • R est orienté vers l’analyse statistique (calculs et graphiques).
  • Le projet R naît en 1993, se structure en 1997 et la version 1.0.0 est publiée en 2000.
  • La R Core Team est un groupe d’une vingtaine de personnes au cœur du développement du langage R.
  • R est essentiellement codé en C, R et Fortran.
  • De très nombreux.ses utilisateur.trices à travers le monde.
  • Utilisé dans un grand nombre de disciplines.
  • Un large essor dans le monde académique mais aussi dans les entreprises privées.
  • Des conférences dédiées : UseR (internationale), Rencontres R (française), ….
  • Le R Journal paraît environ deux fois par an, les articles sont en accès libre et soumis à un comité de lecture.

1.2 C’est quoi un package (library) R ?

  • Un package est l’unité fondamentale de code partageable dans R.
  • Un package contient du code et/ou des données, de la documentation, des tests.
  • 30 packages sont automatiquement distribués lors de l’installation de R.
  • Le dépôt officiel des packages R est le CRAN (The Comprehensive R Archive Network).
  • Plus de 16000 packages existent sur CRAN (août 2020).
  • Tout le monde peut proposer un nouveau package pour valoriser et partager ses méthodes, ses codes, ses données.
  • Un ensemble de contraintes pour créer et soumettre votre propre package (R Core Team 2018b ; Wickham 2015b) facilitent largement l’installation et l’exploration de nouveaux packages.
  • install.packages("nomPkg") : installe le package nomPkg localement sur votre machine.
  • library(nomPkg) : charge le package nomPkg dans votre session R, dans votre environnement R ; cette commande doit être exécutée à chaque nouvelle session, sauf si vous avez sauvegardé votre session.
# installation du package 'ggplot2' sur votre machine depuis le miroir de Lyon 1
install.packages("ggplot2", repos = "https://pbil.univ-lyon1.fr/CRAN/")
# chargement du package 'ggplot2' dans votre session R en cours
library(ggplot2)


1.3 Bien citer R

Dans tous documents produits qui incluent du code R, le logiciel et les packages utilisés doivent être cités ; cette pratique est essentielle à l’exitence et au développement des logiciels libres.

  • citation() : retourne la manière de citer le logiciel R.
  • citation("nomPkg") : retourne la manière de citer le package nomPkg.
# référence bibliographique pour citer le logiciel R
citation()
## 
## To cite R in publications use:
## 
##   R Core Team (2020). R: A language and environment for statistical
##   computing. R Foundation for Statistical Computing, Vienna, Austria.
##   URL https://www.R-project.org/.
## 
## A BibTeX entry for LaTeX users is
## 
##   @Manual{,
##     title = {R: A Language and Environment for Statistical Computing},
##     author = {{R Core Team}},
##     organization = {R Foundation for Statistical Computing},
##     address = {Vienna, Austria},
##     year = {2020},
##     url = {https://www.R-project.org/},
##   }
## 
## We have invested a lot of time and effort in creating R, please cite it
## when using it for data analysis. See also 'citation("pkgname")' for
## citing R packages.

# référence bibliographique pour citer le package 'ggplot2'
citation("ggplot2")
## 
## To cite ggplot2 in publications, please use:
## 
##   H. Wickham. ggplot2: Elegant Graphics for Data Analysis.
##   Springer-Verlag New York, 2016.
## 
## A BibTeX entry for LaTeX users is
## 
##   @Book{,
##     author = {Hadley Wickham},
##     title = {ggplot2: Elegant Graphics for Data Analysis},
##     publisher = {Springer-Verlag New York},
##     year = {2016},
##     isbn = {978-3-319-24277-4},
##     url = {https://ggplot2.tidyverse.org},
##   }


1.4 Fichiers et répertoire de travail

  • Une session R est définie par l’environnement global courant, dans lequel se trouvent des packages, fonctions, données, variables importées ou créées.
  • Une session R peut être sauvegardée pour être chargée plus tard ou ailleurs :
    • l’environnement est sauvegardée dans un fichier qui se nomme .RData,
    • l’historique des commandes utilisées dans la session est sauvegardé dans un fichier qui se nomme .Rhistory.
  • De manière pratique, vous travaillez, d’un côté, avec un éditeur dans lequel vous pouvez modifier votre script (un fichier avec une extension .R qui permet d’enregistrer les étapes qui vous ont permis de créer les objets R) et, d’un autre côté, une invite de commande dans laquelle vous accédez à votre session R.
  • getwd() : retourne le chemin du répertoire courant de travail.
  • setwd() : définit le répertoire de travail.
  • .libPaths() : retourne le nom de tous les répertoires contenant les packages R installés sur la machine.
  • sessionInfo() : retourne des informations sur la session R en cours.


A VOUS ! (avec des commandes R)

  • 1.4.A - Quel est votre répertoire courant de travail ?
  • 1.4.B - Dans combien de répertoires les packages R de votre machine sont localisés ?
  • 1.4.C - Quelle est la version de R utilisée par votre session ?


1.5 Support et aide

  • Le nom du logiciel ne facilite pas les recherches sur le web.
  • Mais la communauté des utilisateur.trices est mature et très active.
  • Beaucoup de supports de formation, de documents disponibles, de forums, …

La documentation officielle de R

  • Elle a l’avantage et l’inconvénient d’être exhaustive sur les rouages internes au langage et au logiciel.
  • Difficile de s’y retrouver et de comprendre tous les détails, mais les règles qu’elle contient prévalent sur toute information qui peut être trouvée par ailleurs.
  • Elle se compose de six guides complets (dans RStudio, rubrique Manuals de l’onglet Help/R Help).
  • An Introduction to R et R Data Import/Export sont les manuels les plus pertinents pour débuter.
  • Writing R Extensions est la ressource officielle pour développer un package R.

Se documenter depuis votre session R

  • Tous les objets R qui existent dans votre environnement (package, fonction, données) sont documentés.
  • Si vous connaissez le nom de ce que vous cherchez, vous pouvez facilement accéder à une description détaillée, à des exemples, des sources, des paramètres d’entrée et des sorties.
  • ?nomFctn ou help("nomFctn") : retourne la fiche d’aide de la fonction nomFctn.
  • example(nomFctn) : exécute l’exemple associé à la fonction nomFctn.
  • vignette(package = "nomPkg") : charge la vignette du package nomPkg, un guide d’utilisation plus complet du package nomPkg.

D’autres documentations utiles

N’hésitez pas à me communiquer vos ressources préférées pour que je puisse les partager avec vos collègues de promo !

# documentation sur le package 'ggplot2'
help("ggplot2-package")

# documentation sur la fonction 'geom_histogram' (package 'ggplot2')
?geom_histogram
help("geom_histogram")
help("geom_histogram", package = "ggplot2") # pour lever une éventuelle ambigüité, si un même nom de fonction a été utilisé dans plusieurs packages

# vignettes du package 'ggplot2'
vignette(package = "ggplot2")
vignette("ggplot2-specs", package = "ggplot2") # quand il y a plusieurs vignettes dans le package


2 Les bases du langage R

  • R est sensible à la casse (majuscule / minuscule).
  • Les commentaires sont précédés du signe #.
  • Pas de ; à la fin des lignes de commande (comme c’est le cas dans d’autres langages).
  • R gère les décimales avec un point (pas une virgule).
  • Le symbole <- permet d’affecter une valeur (élément de droite) à une variable (élément de gauche).

2.1 Les données

2.1.1 Importer et exporter des données

Importer des données

  • read.table() : importe un fichier de données tabulées.
  • scan(), readline() et readLines() : importent des données de manière plus flexible (format des données, options d’import, saisie interactive).
  • data() et load() : importent des jeux de données (généralement au format .RData ou .rda).

D’autres packages pour lire vos données :

  • Le package readr (Wickham, Hester, and Francois 2018) pour accèder aux fichiers plats de manière performante.
  • Les packages readxl (Wickham and Bryan 2019) et XLConnect (GmbH et al. 2018) pour traiter les fichiers Excel.
  • Le package foreign (R Core Team 2017) pour lire et écrire des données issues de logiciels tels que SPSS, SAS, Stata, …
  • Le package seqinR (Charif and Lobry 2007) et sa fonction read.fasta pour faciliter l’import de données génomiques.
  • Le package rjson (Couture-Beil 2018) pour traiter les fichiers JSON.
  • Le package XML (Lang and CRAN Team 2019) pour accèder à des données issues du web.
  • Les packages bigmemory (Kane, Emerson, and Weston 2013) et ff (Adler et al. 2018) pour gérer efficacement les données volumineuses.

Quand R charge un jeu de données, toutes les données sont importées dans l’environnement R et sont donc disponibles dans la mémoire :

  • ce qui permet de bonnes performances pour les calculs effectués sur ces données,
  • ce qui peut être problématique quand le volume des données est important.
# chargement du jeu de données 'doubs' du package 'ade4'
install.packages("ade4")
library(ade4)
data(doubs)


Exporter et sauver des données

Exporter des données a un intérêt (1) quand les données initialement importées ont été modifiées dans R, ou (2) quand les données ont été générées / simulées dans R.

  • save() : sauvegarde un ensemble d’objets R dans un fichier spécifique (généralement au format .RData ou .rda).
  • write.table : enregistre des données tabulées dans un fichier.

2.1.2 Les types de données

Ici, sont présentés les principaux types de données. Il existe d’autres types de données (dates, séries temporelles, données spatiales, …) et les possibilités de typage sont enrichies par les nombreux packages R existants.

Les données numériques

  • numeric, double, integer
  • is.numeric(), is.double(), is.integer() : testent si un objet est numérique.
  • as.numeric(), as.double(), as.integer() : convertissent un objet en numérique.

Les facteurs

Un facteur est une variable catégorielle qui possède un attribut levels définissant l’ensemble des valeurs qu’il peut prendre.

  • factor
  • is.factor() : teste si un objet est un facteur.
  • as.factor() : convertit un objet en facteur.
  • levels(), levels() <- : retourne et affecte les niveaux de valeur d’un facteur.

Les caractères

  • character
  • is.character() : teste si un objet est un caratère.
  • as.character() : convertit un objet en caractère.
  • paste() : concatène deux chaînes de caractères.
  • letters, LETTERS, month.abb, month.name : retournent des chaînes de caractères prédéfinies.

Les valeurs booléennes

  • TRUE et FALSE
  • is.logical() : teste si un objet est booléen.
  • as.logical() : convertit un objet en booléen.
  • isTRUE() : teste si une valeur est égale à TRUE.
  • ! (négation logique), & (‘et’ logique), | (‘ou’ logique)

Les valeurs manquantes

  • NA (i.e. Not Available) est un indicateur de valeur manquante. is.na() teste si une valeur est manquante.
  • NaN (i.e. Not a Number) matérialise une valeur numérique qui n’est pas réelle. is.nan() teste si un numérique n’est pas réel.
  • NULL représente un objet vide. is.null() teste si une valeur est définie. NULL est différent de NA.

2.1.3 Les structures de données

Quelques commandes utiles

  • str() : retourne la structure d’un objet R.
  • class() et typeof() : retournent la classe (au sens de la Programmation Orientée Objet) et le type d’un objet (au sens du typage dans R). La classe d’un objet peut être définie / modifiée par l’utilisateur.trice, pas son type. Les deux fonctions peuvent renvoyer le même résultat.
  • names(), colnames() et rownames() : retournent les noms d’un objet, le nom de ses colonnes et le nom de ses lignes.
  • length() et dim() : retournent la longueur et la dimension d’un objet.
  • head() et tail() : extraient les premiers et les derniers éléments d’un objet.
  • [, [[ et $ : extraient un ou plusieurs éléments d’un objet.

L’indexation des objets commence à 1 (et non à 0, comme dans certains langages).

L’extraction d’un élément d’un objet peut se faire en spécifiant :

  • un entier positif, pour sélectionner les éléments situés à une position spécifique
  • un entier négatif, pour supprimer les éléments situés à une position spécifique
  • un booléen, pour sélectionner les éléments pour lesquels la valeur est TRUE
  • une chaîne de caractère, pour sélectionner les éléments dont le nom correspond

Les vecteurs

  • Le vecteur est la structure de base des objets dans R.
  • Un vecteur contient nécessairement des données de types homogènes.
  • vector() : crée un vecteur.
  • is.vector() : teste si un objet est un vecteur.
  • as.vector() : convertit un objet en vecteur.
  • seq(), c(), rep(), : : générent quelques vecteurs utiles.

Les matrices

  • Une matrice contient nécessairement des données de types homogènes.
  • matrix() : crée une matrice.
  • is.matrix() : teste si un objet est une matrice.
  • as.matrix() : convertit un objet en matrice.
  • cbind() et rbind() : concatènent les colonnes et les lignes d’une matrice.
  • nrow() et ncol() : retournent le nombre de lignes et de colonnes d’une matrice.

Les data frames

  • Le data.frame est une structure spécifique à R.
  • Un data frame est un tableau à deux dimensions, dans lequel les colonnes peuvent être de types hétérogènes.
  • data.frame() : crée un data frame.
  • is.data.frame() : teste si un objet est un data frame.
  • as.data.frame() : convertit un objet en data frame
  • colnames() et rownames() : retournent le nom des lignes et des colonnes d’un data frame.

Les listes

  • Une liste peut contenir des données de types et de structures hétérogènes.
  • list() : crée une liste.
  • is.list() : teste si un objet est une liste.
  • as.list() : convertit un objet en liste.
  • unlist() : simplifie une liste en vecteur.
# structure des données 'doubs'
str(doubs)

# 'doubs' est-il une liste ?
is.list(doubs)

# nom des objets contenus dans 'doubs'
names(doubs)

# dimension de l'objet 'fish' de 'doubs'
dim(doubs$fish)

# les 10 premières lignes de 'fish'
head(doubs$fish, 10)
doubs[["fish"]][1:10, ]

# création d'un objet 'dfish'
dfish <- doubs$fish

# nom des colonnes de 'dfish'
names(dfish)
colnames(dfish)

# dimension de 'dfish'
dim(dfish)

# l'objet 'dfish' est-il un data.frame ?
is.data.frame(dfish)

# classe de la colonne 'Cogo' de 'dfish'
class(dfish$Cogo)

# type de la colonne 'Satr' de 'dfish'
typeof(dfish$Satr)

# modification de la classe de la colonne 'Cogo' de 'dfish'
class(dfish$Cogo) <- "character"

# structure de 'dfish'
str(dfish)

# modification du type de la colonne 'Satr' de 'dfish'
# renvoie une erreur : impossible de modifier le 'type' d'une variable
# typeof(dfish$Satr) <- "character"


2.1.4 Manipuler les données

  • pour nettoyer les données brutes que vous venez d’importer
  • plutôt depuis votre session R que directement dans votre fichier des données brutes
  • en gardant une trace des étapes de transformation dans un script R afin d’éventuellement les rejouer
  • pour rendre vos données exploitables au sens d’une analyse statistique
  • trier, sélectionner, couper, jointer, …

Quelques outils pour le ménage et le rangement

  • sort() , order() et rank() : trient et ordonnent un vecteur.
  • sample() : échantillonne un nombre d’éléments, avec ou sans remise.
  • table() : construit une table de contingence.
  • which() : retourne les positions des éléments pour lesquels la condition est vraie.
  • na.omit() : supprime les valeurs NA d’un objet.
  • subset() : sélectionne un sous-ensemble de données.
  • %in% et match() : retournent les positions des éléments d’un premier objet qui correspondent avec les éléments d’un deuxième objet.
  • cut() : coupe un vecteur en plusieurs sections et le convertit en facteur.
  • with() : évalue une expression dans un environnement de données.
  • na.fail(), na.exclude(), na.pass() : traitent les NA.

Des spécialistes de la grammaire des données

  • Le package plyr(Wickham 2011) : arrange(), mutate(), summarise(), join(), …
  • Le package dplyr (Wickham et al. 2017) : filter(), arrange(), select(), rename(), mutate(), transmute(), summarise(), …
  • Le package stringr (Wickham 2018)
  • Le package tidyr (Wickham and Henry 2018)
  • Le package magrittr (Bache and Wickham 2014)
  • Le package stringi (Gagolewski 2017)
  • …


AVANT DE COMMENCER : Prenez bien connaissance, en Annexe, de la documentation liée aux jeux de données que vous allez étudier sur les varis dans la suite de ce cours.


A VOUS ! (avec des commandes R)

  • 2.1.A - Chargez le jeu de données dfvaris_litter.Rdata dans votre session R.
  • 2.1.B - Quelle est la structure de ce jeu de données (dimension, nombre de portées, nom des variables, type de variables, données manquantes, …) ?
  • 2.1.C - Combien d’espèces sont présentes dans ce jeu de données ? Et combien de portées sont suivies par espèce ?
  • 2.1.D - Créez un nouveau jeu de données sub_dfvaris_litter contenant 100 portées (prises au hasard) de chaque espèce.
  • 2.1.E - Ajoutez une nouvelle variable PAD (Parental Age Difference) dans dfvaris_litter, égale à l’âge du père moins l’âge de la mère.


2.2 Eléments de programmation

2.2.1 Les structures de contrôle

Les structures conditionnelles

  • if(test) expr.oui else expr.non
  • switch(var, val1 = expr.val1, val2 = expr.val2, val3 = expr.val3, ...)

Les structures itératives

  • for(var in seq) expr
  • while(test) expr. L’expression continue à être exécutée tant que la condition est respectée.
  • repeat expr
  • break interrompt une boucle ; next passe à l’itération suivante.
  • La boucle for incrémente elle-même l’itérateur.
  • Pour while et repeat, il est primordial d’incrémenter explicitement l’itérateur, sans quoi, le code pourrait boucler à l’infini et endommager un programme.

2.2.2 Les fonctions

Utiliser une fonction existante

  • Plusieurs dizaines de fonctions ont déjà été utilisées depuis le début de ce document (install.packages(), library(), read.table(), data(), is.numeric(), as.numeric(), …).
  • args(), formals() et formalArgs() retournent, sous différentes formes, les éléments qui définissent une fonction.
  • Quand une fonction est appelée, il n’est pas impératif de spécifier le nom des arguments auxquels une valeur est associée, à condition qu’il n’y ait pas d’ambiguïté entre ces arguments utilisés. Cependant, pour une meilleure lisibilité et une meilleure performance, il est recommandé d’expliciter le nom des arguments auxquels une valeur est associée.
  • ls() liste l’ensemble des objets existants dans un environnement R.
ls()
args(ls)
args("plot")
args("plot.default")
str(plot.default)


Créer votre propre fonction

  • Il est bien sûr possible de créer votre propre fonction.
  • Vous pouvez définir une valeur par défaut pour un ou tous les arguments de votre fonction. Déterminer des valeurs par défaut peut faciliter l’usage de votre fonction.
  • Plus l’indentation du corps de la fonction sera soignée, plus la fonction sera lisible, compréhensible, donc facilement utilisable.
  • Il est recommandé, au début de votre fonction, d’ajouter des tests pour contrôler la validité des valeurs passées en paramètre par l’utilisateur.trice et pour l’orienter, grâce à des messages explicites, sur les éléments à corriger.
  • return() : matérialise les éléments renvoyés par la fonction créée.
  • invisible() : retourne une copie (temporairement) invisible d’un objet.
  • on.exit() : stocke des valeurs d’éléments qui seront restaurées à la fin / sortie de la fonction.
  • stop(), stopifnot(), message() et error() : caractérisent les messages envoyés à l’utilisateur.trice au cours de l’exécution d’une fonction.


A VOUS ! (avec des commandes R)

Supposez une fonction info_vect qui prend en entrée un vecteur et qui renvoie une liste contenant la classe de ce vecteur, sa longueur, le résultat de la fonction summary appliquée à ce vecteur et le nombre de valeurs manquantes contenues dans ce vecteur.

  • 2.2.A - Avant même de créer cette fonction, pouvez-vous dire quelle est la taille de l’objet qu’elle retourne ?
  • 2.2.B - Créez cette fonction.
  • 2.2.C - Appliquez cette fonction à la variable survlitter48h du jeu de données dfvaris_litter.
  • 2.2.D - Faire une boucle pour appliquer cette fonction à chaque variable (colonne) du jeu de données dfvaris_litter.

Pour aller plus loin :

  • 2.2.E - Remplacez la boucle développée dans la question 2.2.D par une fonction lapply qui vous donnera le même résultat.
  • 2.2.F - Entre ces deux méthodes (2.2.D vs 2.2.E), quelle la plus rapide ?


3 Les graphiques dans R


  • Lisibilité : l’objectif est de communiquer un message scientifique clair.
  • Reproductibilité : le graphique est construit par un script R (ne pas bricoler un graphique via un logiciel de dessin).
  • Honnêteté et objectivité : ne pas distordre le graphique pour biaiser l’interprétation des analyses.


Quelques exemples de mauvaises représentations graphiques


Ex1




Ex2




Ex3




3.1 Réfléchir votre représentation graphique

Un graphique scientifique

  • Un graphique n’est pas une oeuvre d’art !
  • Définir, en amont, le message scientifique que vous souhaitez communiquer.
  • Ne pas surcharger : un seul message par graphique ; éviter les distractions visuelles (trop de couleurs, trop d’étiquettes, fond trop présent, police exotique, …).
  • Procéder en deux étapes :
    • explorer vos données : les graphiques doivent être créés rapidement et efficacement, leur apparence a peu d’importance ;
    • présenter vos données : les graphiques doivent être de haute qualité, reproductibles.

Le choix du graphique

  • Adapter le type de graphique aux données représentées (source : https://www.data-to-viz.com/).
  • Adapter le type de graphique au média de communication utilisé (temps d’exposition visuelle).
  • Eviter les graphiques circulaires ou en 3D : l’œil humain compare mal les surfaces.

Annoter judicieusement votre graphique

  • Ajouter un titre global, des noms aux axes : ni trop court, ni trop long.
  • Ajouter une légende si nécessaire ou, si possible, s’en passer pour alléger le graphique.
  • Attirer l’attention sur un élément particulier en intégrant des éléments graphiques (texte, couleur).
  • Inclure une expression mathématique avec expression().

Travailler les couleurs

  • L’information apportée par les couleurs doit avoir un sens.
  • Tenir compte des défaillances visuelles de vos potentiel.les lecteur.trices.
  • Le package grDevices (R Core Team 2018a) : colors(), palette(), rainbow() et grey().
  • Le package RColorBrewer (Neuwirth 2014) : brewer.pal() et display.brewer.all().
  • Les packages wesanderson (Ram and Wickham 2018), ggsci (Xiao 2018), ggthemes (Arnold 2019), colourpicker (Attali 2017), …


A VOUS ! (avec des commandes R)

  • 3.1.A - A l’aide du package graphics, inspirez-vous de la Figure S1 (ci-dessous et en annexe de l’article de Tidière et al. (2018)) pour créer un graphique contenant :
    • l’âge de la mère en fonction de l’âge du père de chaque portée, en différenciant les deux espèces
    • des titres aux axes
    • la droite de régression du modèle linéaire expliquant l’âge du père par l’âge de la mère
    • l’équation de cette droite de régression
    • la droite représentant un modèle d’accouplement des varis où l’âge du père est égal à l’âge de la mère (i.e. 1ère bissectrice)
    • des points supplémentaires représentant l’âge moyen du père pour chaque âge de la mère, en différenciant les deux espèces
  • 3.1.B - Pour quelles raisons le graphique produit à la question 3.1.A est légèrement différent de celui publié dans Tidière et al. (2018) ?
  • 3.1.C - Proposez des améliorations au graphique qui a été publié.



3.2 Des graphiques pour l’analyse statistique

Les graphiques font partie intégrante de l’analyse statistique des données.

Dans R, la visualisation graphique des données est géré historiquement par le package graphics (R Core Team 2018a) :

  • Fonction centrale et générique pour représenter des données : plot().
  • Fonctions graphiques de premier niveau : boxplot(), hist(), image(), contour(), dotchart(), curve(), barplot(), stripchart(), pie(), stars(), matplot(), pairs(), mosaicplot(), smoothScatter(), …
  • Certaines fonctions de premier niveau retournent les éléments statistiques qui ont permis la construction du graphique : hist(), boxplot(), barplot().
  • Fonctions graphiques de deuxième niveau (i.e. utilisables uniquement si une fonction graphique de premier niveau a été appelée auparavant) : points(), lines(), segments(), text(), abline(), legend(), title(), mtext(), rect(), arrows(), polygon(), grid(), rug(), …
  • Graphiques quantile-quantile : qqnorm(), qqline(), qqplot()
  • Gérer les paramètres graphiques : par().
  • Sauvegarder un graphique : graphics.off(), pdf(), png() et dev.off().


A
# Distribution de l'âge des mères

# Création de l'histogramme de l'âge des mères
h_agedam <- hist(dfvaris_litter$agedam, freq = FALSE, 
                 main = "Distribution de l'âge des mères",
                 xlab = "Age de la mère en années", ylab = "Densité")

# Ajout d'une courbe de densité
dens_agedam <- density(dfvaris_litter$agedam)
lines(dens_agedam)

# Ajout d'une ligne verticale ayant pour abscisse l'âge moyen des mères
abline(v = mean(dfvaris_litter$agedam), col = "red")

# Coloration de l'aire sous la courbe de densité pour les valeurs inférieures au 1er quartile
qrtle1 <- summary(dfvaris_litter$agedam)["1st Qu."]
polygon(c(0, dens_agedam$x[dens_agedam$x <= qrtle1]), 
        c(dens_agedam$y[dens_agedam$x <= qrtle1], 0), 
        col = rgb(1, 0, 0, alpha = 0.3))


A VOUS ! (avec des commandes R)

  • 3.2.A - Complétez ce graphique en colorant l’aire sous la courbe de densité pour les valeurs supérieures au 3ème quartile.


B
# Distribution de l'âge des mères et des pères en fonction de l'espèce

# Préparation d'une zone graphique à deux lignes et deux colonnes
par(mfrow = c(2, 2))

# Création d'un vecteur contenant l'âge des mères de l'espèce V. Rubra
dfagedam_vr <- dfvaris_litter$agedam[dfvaris_litter$species == "Vrubra"]
# Création de l'histogramme de l'âge des mères de l'espèce V. Rubra
hist(dfagedam_vr, freq = FALSE, main = "Distribution de l'âge des mères\nde l'espèce V. Rubra", 
     xlab = "Age de la mère", ylab = "Densité", col = "#69b3a2")
# Ajout de la courbe de densité de l'âge des mères de l'espèce V. Rubra
lines(density(dfagedam_vr))

# Création d'un vecteur contenant l'âge des mères de l'espèce V. Variegata
dfagedam_vv <- dfvaris_litter$agedam[dfvaris_litter$species == "Vvariegata"]
# Création de l'histogramme de l'âge des mères de l'espèce V. Variegata
hist(dfagedam_vv, freq = FALSE, main = "Distribution de l'âge des mères\nde l'espèce V. Variegata", 
     xlab = "Age de la mère", ylab = "", col = "#404080")
# Ajout de la courbe de densité de l'âge des mères de l'espèce V. Variegata
lines(density(dfagedam_vv))

# Création d'un vecteur contenant l'âge des pères de l'espèce V. Rubra
dfagesire_vr <- dfvaris_litter$agesire[dfvaris_litter$species == "Vrubra"]
# Création de l'histogramme de l'âge des pères de l'espèce V. Rubra
hist(dfagesire_vr, freq = FALSE, main = "Distribution de l'âge des pères\nde l'espèce V. Rubra",
     xlab = "Age du père", ylab = "Densité", col = "#69b3a2")
# Ajout de la courbe de densité de l'âge des pères de l'espèce V. Rubra
lines(density(dfagesire_vr))


A VOUS ! (avec des commandes R)

  • 3.2.B - Sur le modèle de ces 3 sous-graphiques, complétez ce graphique en construisant un 4ème sous-graphique représentant la distribution de l’âge des pères de l’espèce V. Variegata.


C
# Distribution de l'âge des mères en fonction de l'espèce

# Création du boxplot de l'âge des mères en fonction de l'espèce et affichage des statistiques de calcul
(bxpt_agedam <- boxplot(dfvaris_litter$agedam ~ dfvaris_litter$species, 
                        xlab = "", ylab = "Age de la mère", col = c("#69b3a2", "#404080")))

## $stats
##      [,1] [,2]
## [1,]    2    2
## [2,]    5    5
## [3,]    8    8
## [4,]   12   11
## [5,]   21   20
## 
## $n
## [1] 378 962
## 
## $conf
##          [,1]     [,2]
## [1,] 7.431135 7.694353
## [2,] 8.568865 8.305647
## 
## $out
##  [1] 23 30 22 22 22 23 23 21 21 21 23 22 21 23 24 26 21 23
## 
## $group
##  [1] 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
## 
## $names
## [1] "Vrubra"     "Vvariegata"


A VOUS ! (avec des commandes R)

  • 3.2.C - Sur le modèle de ce graphique, construisez un boxplot représentant la distribution de l’âge des pères en fonction de l’espèce.


D
# Distribution de la taille des portées en fonction de l'espèce

# Création du boxplot de la taille des portées en fonction de l'espèce et affichage des statistiques de calcul
(bxpt_LSbirth <- boxplot(dfvaris_litter$littersizebirth ~ dfvaris_litter$species,
                         xlab = "", ylab = "Taille de la portée", col = c("#69b3a2", "#404080")))

## $stats
##      [,1] [,2]
## [1,]    1    1
## [2,]    1    1
## [3,]    2    2
## [4,]    3    2
## [5,]    5    3
## 
## $n
## [1] 378 962
## 
## $conf
##          [,1]     [,2]
## [1,] 1.837467 1.949059
## [2,] 2.162533 2.050941
## 
## $out
##  [1] 5 4 4 4 4 4 4 4 4 4 5 4 5 4 5 4 4 4 4 4 5 6 4 4 4 4 5 4 4 4 4 4 4 4 4 4 6 4
## [39] 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5 4 4 4 4
## 
## $group
##  [1] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
## [39] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
## 
## $names
## [1] "Vrubra"     "Vvariegata"


3.3 Des visualisations performantes

Dans R, la visualisation graphique des données a été réinventé par des packages comme grid (Murrell 2011 ; R Core Team 2018a), lattice (Sarkar 2008), ggplot2 (Wickham 2016).

Dans ggplot2 :

  • Les graphiques sont des objets stockables et modifiables.
  • Les graphiques sont construits à partir d’un objet formula qui exprime la dépendance entre les variables à représenter.
  • Les objets graphiques sont esthétiquement plus modernes, plus facilement modifiables, plus facile à combiner.
  • De plus en plus utilisé, dans tous les domaines.
  • Propose un grand nombre de fonctionnalités.
  • En contrepartie, la grammaire liée à ces graphiques se revèle plus complexe à appréhender pour construire des graphiques élaborés.



A
# Distribution de l'âge des mères (voir onglet A du chapitre 3.2)

# Chargement de la librairie ggplot2
library(ggplot2)

# Création d'un data.frame contenant les coordonnées de la courbe de densité de l'âge des mères
df_dens_agedam <- as.data.frame(cbind(x = dens_agedam$x, y = dens_agedam$y))

# Création et affichage de l'histogramme de l'âge des mères
(gg_hist_agedam <- ggplot(data = dfvaris_litter, aes(x = agedam)) + 
    ggtitle("Distribution de l'âge des mères") + 
    xlab("Age de la mère en années") + ylab("Densité") +
    geom_histogram(alpha = 0.4, breaks = h_agedam$breaks, aes(y = ..density..), colour = "black") +
    geom_vline(xintercept = mean(dfvaris_litter$agedam), colour = "red") +
    geom_density(alpha = 0.2) +
    geom_ribbon(data = subset(df_dens_agedam, x <= qrtle1), aes(x = x, ymax = y), ymin = 0, fill = "red", alpha = 0.3) +
    geom_ribbon(data = subset(df_dens_agedam, x >= qrtle3), aes(x = x, ymax = y), ymin = 0, fill = "red", alpha = 0.3)
)


B
# Distribution de l’âge des mères et des pères en fonction de l'espèce (voir onglet B du chapitre 3.2)

# Chargement des librairies ggplot2 et gridExtra
library(ggplot2)
library(gridExtra)

# Préparation d'une liste qui contiendra les graphiques à afficher
gg_hist_age_spe <- list()

# Création de l'histogramme de l'âge des mères pour les deux espèces
gg_hist_age_spe[[1]] <- ggplot(data = dfvaris_litter, aes(x = agedam)) + 
  ggtitle("") + xlab("Age de la mère en années") + ylab("Densité") +
  geom_histogram(alpha = 0.4, aes(y = ..density.., fill = species), bins = 15, color = "grey30") +
  geom_density(alpha = 0.2) +
  scale_fill_manual(values = c("#69b3a2", "#404080")) +
  facet_wrap(~ species) +
  theme(legend.position = "none")

# Création de l'histogramme de l'âge des pères pour les deux espèces
gg_hist_age_spe[[2]] <- ggplot(data = dfvaris_litter, aes(x = agesire)) + 
  ggtitle("") + xlab("Age du père en années") + ylab("Densité") +
  geom_histogram(alpha = 0.4, aes(y = ..density.., fill = species), bins = 10, color = "grey30") +
  geom_density(alpha = 0.2) +
  scale_fill_manual(values = c("#69b3a2", "#404080")) +
  facet_wrap(~ species) +
  theme(legend.position = "none")

# Organisation et affichage des quatre graphiques
do.call(grid.arrange, c(gg_hist_age_spe, nrow = 2))


C
# Distribution de l'âge des mères en fonction de l'espèce (voir onglet C du chapitre 3.2)

# Chargement des librairies ggplot2 et gridExtra
library(ggplot2)
library(gridExtra)

# Préparation d'une liste qui contiendra les graphiques à afficher
gg_bxplt_age_spe <- list()

# Création du boxplot de l'âge des mères en fonction de l'espèce
gg_bxplt_age_spe[[1]] <- ggplot(data = dfvaris_litter, aes(x = species, y = agedam)) +
  geom_boxplot(aes(fill = factor(species)), fill = c("#69b3a2", "#404080")) + guides(fill=FALSE) +
  xlab("") + ylab("Age de la mère")

# Création du boxplot de l'âge des pères en fonction de l'espèce
gg_bxplt_age_spe[[2]] <- ggplot(data=dfvaris_litter, aes(x = species, y = agesire)) + 
  geom_boxplot(aes(fill = factor(species)), fill = c("#69b3a2", "#404080")) + guides(fill=FALSE) +
  xlab("") + ylab("Age du père")

# Organisation et affichage des quatre graphiques
do.call(grid.arrange, c(gg_bxplt_age_spe, ncol = 2))


D
# Distribution de la taille des portées en fonction de l'espèce (voir onglet D du chapitre 3.2)

# Chargement des librairies ggplot2 et gridExtra
library(ggplot2)

# Création du boxplot de la taille des portées en fonction de l'espèce
(gg_bxplt_ls_spe <- ggplot(dfvaris_litter, aes(x = species, y = littersizebirth)) + 
   xlab("") + ylab("Taille de la portée") +
   geom_boxplot(fill = c("#69b3a2", "#404080")))

# Création du 'violin plot' de la taille des portées en fonction de l'espèce
(gg_violin_ls_spe <- ggplot(dfvaris_litter, aes(x = species, y = littersizebirth, fill = species)) + 
    xlab("") + ylab("Taille de la portée") +
    geom_violin(alpha = 0.2) +
    scale_fill_manual(values = c("#69b3a2", "#404080")))

# Création du boxplot (avec les points) de la taille des portées en fonction de l'espèce
(gg_jitter_ls_spe <- ggplot(dfvaris_litter, aes(x = species, y = littersizebirth)) + 
    xlab("") + ylab("Taille de la portée") +
    geom_boxplot(fill = c("#69b3a2", "#404080"), alpha = 0.2) + 
    geom_jitter(color = "black", size = 0.4, alpha = 0.9))


A VOUS ! (avec des commandes R)

  • 3.3.A - A l’aide du package ggplot2, reproduisez la figure que vous avez construite à la question 3.1.A, inspirée de la Figure S1 en annexe de l’article de Tidière et al. (2018).




D’autres packages graphiques à explorer

  • Données spatiales et cartographie : rgdal (R. Bivand, Keitt, and Rowlingson 2020), sp(Pebesma and Bivand 2005 ; Bivand, Pebesma, and Gomez-Rubio 2013), rgeos (R. Bivand and Rundel 2020), cartography (Giraud and Lambert 2016 , 2017)
  • Séries temporelles : dygraphs (Vanderkam et al. (2018) ; basé sur la bibliothèque JavaScript dygraphs)
  • Phylogénies : ape (Paradis and Schliep 2019), ggtree (Yu 2020 ; Yu et al. 2018 , 2017), phylogram (Wilkinson and Davy 2018)
  • Graphes (network) : igraph (Csardi and Nepusz 2006)
  • JavaScript dans R : htmlwidgets (Vaidyanathan et al. 2018), rAmCharts (Thieurmel et al. (2019) ; basé sur la bibliothèque JavaScript amcharts.js)
  • …

3.4 Des visualisations interactives

  • Rendre des représentations attractives, originales et faciles à inclure dans des pages web.
  • Déclencher l’intérêt d’un public non-spécialiste.
  • Augmenter le niveau d’information contenu dans les graphiques pour mieux communiquer.
  • Utiliser des packages R qui s’appuient sur des bibliothèques JavaScript.
  • Le développeur ou la développeuse n’a pas besoin d’apprendre un autre langage que R.

Des packages dédiés

  • Graphiques généraux : plotly (Sievert 2018)
  • Données spatiales et cartographie : leaflet (Cheng, Karambelkar, and Xie 2018)
  • Graphes (network) : networkD3 (Allaire et al. 2017), visNetwork (Almende B.V., Thieurmel, and Robert 2019)
  • 3D : threejs (Lewis 2017), rgl (Adler, Murdoch, and others 2019)
  • Tables de données : DT (Xie, Cheng, and Tan 2019)
  • Heatmaps : d3heatmap (Cheng and Galili 2018)
  • …

Des fonctionnalités automatiquement gérées

  • zoom avant et arrière
  • affichage dynamique d’informations supplémentaires (statistiques, coordonnées) lors du survol ou du clic par la souris
  • apparition et disparition de points
  • export du graphique
  • …


A
# Relation entre l'âge du père et l'âge de la mère chez deux espèces de varis
# Attention : certains éléments graphiques du ggplot initial ne sont pas conservés par ggplotly (cf le sous-titre qui a disparu).

library(plotly)
## 
## Attaching package: 'plotly'
## The following object is masked from 'package:ggplot2':
## 
##     last_plot
## The following object is masked from 'package:stats':
## 
##     filter
## The following object is masked from 'package:graphics':
## 
##     layout
ggplotly(gg_agedamsire)


B
# Distribution de l'âge des mères (voir onglets A des chapitres 3.2 et 3.3)

library(plotly)
ggplotly(gg_hist_agedam)


C
# Distribution de la taille des portées en fonction de l'espèce (voir onglets D des chapitres 3.2 et 3.3)

library(plotly)
ggplotly(gg_bxplt_ls_spe)

4 Des applications web avec shiny

4.1 Introduction

4.1.1 C’est quoi shiny ?

  • shiny (Chang et al. 2017) est un package R.
  • Une application shiny est constituée de deux éléments :
    • une partie qui gère l’interface avec l’utilisateur.trice (User Interface) et définit la mise en page et l’apparence de l’application,
    • une partie qui gère les interactions avec le serveur et contient donc les instructions dont le serveur a besoin pour construire dynamiquement l’application.
  • Le code de l’application shiny peut être contenu dans un seul fichier appelé app.R ou dans deux fichiers distincts appelés ui.R et server.R. Cette dernière solution est à priviliégier pour plus de clarté dans le code.
  • Une application est lancée par la commande runApp() ou par le bouton ‘Run App’ de RStudio.
  • La totalité d’une application shiny peut être codée en R ; il n’est pas nécessaire de connaître d’autres langages.
  • Il est cependant possible d’intégrer du css, du html, du JavaScript, …
  • De nombreux packages ont été développés autour de shiny : shinydashboard (Chang and Borges Ribeiro 2018), shinyWidgets (Perrier, Meyer, and Granjon 2019), shinycssloaders (Sali 2017), shinythemes (Chang 2018), shinyBS (Bailey 2015), shinyjs (Attali 2018), …

Pour qu’une application soit fonctionnelle, les fichiers et les dossiers doivent être organisés comme suit :

  • les fichiers ui.R et server.R doivent être à la racine du répertoire de l’application.
  • des sous-dossiers contenants des données, des scripts peuvent être créés selon les besoins de l’application.
  • un dossier www peut être dédié à des éléments qui ne sont pas nécessaires aux calculs R (images, logos, feuilles de styles, …).
  • le nom du répertoire contenant tous ces éléments détermine le nom de l’application.
  • un fichier global.R peut être ajouté à la racine : il sera exécuté au lancement de l’application, avant tout autre chose, et une seule fois par session.

4.1.2 Côté interface

Dans l’interface, on distingue :

  • les inputs : la valeur de ces éléments va être définie par l’utilisateur.trice, soit par saisie de la valeur, soit par manipulation de l’élément (sélection, glissement, clic)
  • les outputs : la valeur de ces éléments va être définie par le serveur

4.1.2.1 Les inputs

Les inputs sont gérés via ce que shiny nomme des widgets (window gadgets). Un widget est :

  • défini, a minima, par un nom (non visible dans l’interface mais utilisé dans le code pour accéder à la valeur du widget) et un label (affiché dans l’interface).
  • créé dans le fichier ui.R par une fonction prédéfinie.
  • associé à une valeur déterminée dynamiquement par les interactions avec l’utilisateur.trice puis transmise au serveur.

Ci-dessous, les visuels de quelques widgets dans l’interface d’une application shiny :


Ci-dessous, les fonctions qui créent les widgets précédents dans l’interface et qui devront être définies dans le fichier ui.R :


4.1.2.2 Les outputs

Les outputs positionnés dans l’interface sont, par définition, réatifs, c’est-à-dire que leur contenu est modifié en réaction à une modification de l’interface (action de la part de l’utilisateur.trice). Le comportement des outputs sera établi du côté serveur par des fonctions render* (voir chapitre suivant).

Ci-dessous, les fonctions qui créent des outputs dans l’interface et qui devront être définies dans le fichier ui.R :

4.1.2.3 La mise en page et l’apparence de l’application

Les panels

  • pour organiser la mise en page de l’interface.
  • contiennent et regroupent plusieurs éléments de l’interface (inputs et/ou outputs).
  • wellPanel(), sidebarPanel(), mainPanel(), conditionalPanel(), headerPanel(), fixedPanel(), tabPanel(), titlePanel(), …

Personnalisation

Les balises HTML sont nombreuses et permettent de définir finement tous les aspects d’une mise en page. Grâce à shiny, la richesse du HTML est accessible dans R via :

  • des fonctions wrapper (fonctions R qui appellent des tags HTML prédéfinis) pour intégrer des éléments de mise en forme : hr(), br(), a(), p(), div(), …
  • des tags HTML pour d’autres éléments de mise en forme (voir ?shiny::tags et names(tags)).
  • une feuille de style css qui devra être placée dans le répertoire www.

4.1.3 Côté serveur

A chaque fonction *Output() définie côté interface (voir chapitre précédent) correspond une fonction render*() définie côté server. A noter : si vous vous trompez de fonction associée, cela ne génèrera pas forcément une erreur mais engendrera sûrement un affichage vide.


shiny propose plusieurs fonctions pour gérer les différentes formes de réactivité des outputs :

  • la fonction reactive() permet de moduler la réactivité des éléments ; elle est utile notament quand certains morceaux de code sont utilisés par plusieurs outputs.
  • les fonctions eventReactive(), observe() et observeEvent() permettent de déclencher ou retarder une réaction.
  • la fonction isolate() bloque une réaction.

4.2 Se familiariser et se perfectionner avec shiny

4.2.1 Exemples d’applications shiny


Ex0
# liste les exemples d'applis shiny disponibles dans le package 'shiny'
shiny::runExample()
## Valid examples are "01_hello", "02_text", "03_reactivity", "04_mpg", "05_sliders", "06_tabsets", "07_widgets", "08_html", "09_upload", "10_download", "11_timer"
Ex1
# lancement de l'exemple 4

library(shiny)

shinyAppDir(
  system.file("examples/04_mpg", package = "shiny"),
  options = list(width = "100%", height = 700)
)


Ex2
# lancement d'une application définie par une partie 'ui' et une partie 'serveur'

library(shiny)

shinyApp(
  
  ui = fluidPage(
    selectInput("region", "Region:",
                choices = colnames(WorldPhones)),
    plotOutput("phonePlot")
  ),
  
  server = function(input, output) {
    output$phonePlot = renderPlot({
      barplot(WorldPhones[,input$region]*1000,
              ylab = "Number of Telephones", xlab = "Year")
    })
  },
  
  options = list(height = 500)
)



Ex3
# lancement d'une application passée à la fonction 'runApp'

library(shiny)

app <- shinyApp(
  ui = fluidPage(
    numericInput("n", "n", 1),
    plotOutput("plot")
  ),
  server = function(input, output) {
    output$plot <- renderPlot( plot(head(cars, input$n)) )
  }
)

runApp(app)




4.2.2 Lancer une application à partir d’un code existant


A VOUS ! (avec des commandes R)

  • 4.2.A - Créez et lancez une nouvelle application à partir des codes ci-dessous. Cette application s’appuie sur le jeu de données doubs d’ade4 vu dans la section 2.1. Elle permet de visualiser l’abondance des différentes espèces de poissons prélevés au niveau de 30 sites localisés le long de la rivière Doubs. Ici, vous pourrez fournir une ou plusieurs captures d’écran de votre application.
# ui.R
shinyUI(fluidPage(
  
  # Titre de l'application
  titlePanel("Exploration du jeu de données doubs d'ade4"),
  
  # Menu déroulant pour choisir une espèce
  # La liste des espèces est définie par les colonnes de doubs$fish
  selectInput("espece", "Sélectionnez une espèce:",
              choices = colnames(doubs$fish)),
  
  # Graphique représentant l'abondance de l'espèce sélectionné à chaque position géographique (doubs$xy)
  plotOutput("abondancePlot")
))
# server.R
library(shiny)
library(ade4)

shinyServer(function(input, output) {
  
  output$abondancePlot <- renderPlot({
    
    data(doubs)
    df_espece <- doubs$fish[[input$espece]]
    plot(doubs$xy$x, doubs$xy$y, 
         cex = ifelse(df_espece == 0, 1, df_espece),
         pch = ifelse(df_espece == 0, 4, 19))
  })
})


4.2.3 Créer une application simple

A VOUS ! (avec des commandes R)

  • 4.2.B - Dans le but de proposer un outil qui explore vos analyses sur les données dfvaris_litter, créez une application qui permettra d’afficher la distribution (histogramme et courbe de densité) de l’âge des parents chez les varis (voir les graphiques dans les onglets B des sections 3.2 et 3.3). Cette application contiendra :
    • un titre
    • un paragraphe explicatif sur le jeu de données
    • un objet interactif qui permet à l’utilisateur.trice d’afficher les résultats pour une des deux espèces ou les deux
    • un objet interactif qui permet à l’utilisateur.trice d’afficher les résultats pour le père, la mère ou les deux
    • une zone graphique contenant le ou les graphiques (selon les valeurs des deux objets interactifs précédents) de la distribution de l’âge des parents des portées de varis.

Ici, vous pourrez fournir le code R et une ou plusieurs captures d’écran de votre application.


4.2.4 Manipuler des graphiques statiques et interactifs

A VOUS ! (avec des commandes R)

  • 4.2.C - Dans le but de proposer un outil qui explore vos analyses sur les données dfvaris_litter, créez une application qui affiche un même graphique sous 3 formes différentes :
    • le 1er graphique sera généré par les fonctions du package graphics,
    • le 2ème graphique sera généré par les fonctions du package ggplot2
    • et le 3ème graphique sera un graphique intéractif généré par les fonctions des packages ggplot2 et plotly.

Vous pouvez, par exemple, choisir le boxplot de l’onglet D des sections 3.2 et 3.3 (représentant la distribution de la taille des portées en fonction de l’espèce) comme objet d’étude.

Ici, vous pourrez fournir le code R et une ou plusieurs captures d’écran de votre application.


4.2.5 Explorer un graphique dans une application

A VOUS ! (avec des commandes R)

  • 4.2.D - Dans le but de proposer un outil qui explore vos analyses sur les données dfvaris_litter, créez une application qui permet d’explorer la Figure S1 en annexe de l’article de Tidière et al. (2018). Vous pourrez choisir d’utiliser les fonctions du package graphics ou celles du package ggplot2. Vous pourrez, par exemple, proposer des objets réactifs pour :
    • afficher ou pas la légende
    • faire varier la taille des points
    • attribuer une couleur à chaque espèce
    • modifier les titres des axes
    • télécharger le graphique

Ici, vous pourrez fournir le code R et une ou plusieurs captures d’écran de votre application.


Annexes

Données Varis

Les données que nous allons utiliser dans ce cours sont issues du Studbook Internationnal des lémuriens (Whipple 2014 , 2016). Ce Studbook répertorie la majorité des lémuriens de deux espèces (Varecia rubra et Varecia variegata) vivant en captivité (322 zoos à travers le monde) entre 1959 et 2015. Les deux espèces de lémuriens suivies sont deux espèces très proches. On pourra noter que l’âge de sevrage des petits (weaning) est atteint 146 jours après leur naissance (0.4 an), que la maturité sexuelle des individus est atteinte à l’âge de 1.16 an et que 1 à 7 petits peuvent constituer une portée (litter). Le jeu de données complet du Studbook contient 1954 V. rubra et 4169 V. variegata. La qualité de ce jeu de données est attribuable à la rigueur des personnels des zoos, qui peuvent réaliser, grâce aux conditions de captivité, un suivi minutieux des populations.

A partir de ce jeu de données conséquent, Tidière et al. (2018) ont étudié l’effet de l’âge des parents et de leur différence d’âge sur (1) la taille des portées et (2) la survie des descendants. Cet article apporte de nouvelles connaissances sur ces deux espèces de lémuriens et donne donc des pistes pour améliorer leur conservation et la gestion de leur population.

Dans le cadre de ce cours, seule une partie des données de Tidière et al. (2018) va être traitée. Ce jeu de données se nomme dfvaris_litter et compte 1340 portées étudiées sur 13 variables :

  • species : l’espèce (V. rubra ou V. variegata)
  • yearbirth : l’année de naissance de la portée
  • littersizebirth : la taille de la portée
  • littersizeweaning : le nombre d’individus de la portée qui ont atteint l’âge de sevrage
  • sexratiobirth : le sex-ratio de la portée à la naissance
  • sexratioweaning : le sex-ratio de la portée à l’âge de sevrage
  • survlitter48h : le taux de survie de la portée 48 heures après sa naissance
  • survlitterweaning : le taux de survie de la portée à l’âge du sevrage
  • survlittersexmat : le taux de survie de la portée à l’âge de la maturité sexuelle
  • agedam : l’âge de la mère à la naissance de la portée
  • agemaxdam : l’âge maximal atteint par la mère
  • agesire : l’âge du père à la naissance de la portée
  • agemaxsire : l’âge maximal atteint par le père


Adler, Daniel, Christian Gläser, Oleg Nenadic, Jens Oehlschlägel, and Walter Zucchini. 2018. Ff: Memory-Efficient Storage of Large Data on Disk and Fast Access Functions. https://CRAN.R-project.org/package=ff.

Adler, Daniel, Duncan Murdoch, and others. 2019. Rgl: 3D Visualization Using Opengl. https://CRAN.R-project.org/package=rgl.

Allaire, J. J., Christopher Gandrud, Kenton Russell, and CJ Yetman. 2017. NetworkD3: D3 Javascript Network Graphs from R. https://CRAN.R-project.org/package=networkD3.

Almende B.V., Benoit Thieurmel, and Titouan Robert. 2019. VisNetwork: Network Visualization Using ’Vis.js’ Library. https://CRAN.R-project.org/package=visNetwork.

Arnold, Jeffrey B. 2019. Ggthemes: Extra Themes, Scales and Geoms for ’Ggplot2’. https://CRAN.R-project.org/package=ggthemes.

Attali, Dean. 2017. Colourpicker: A Colour Picker Tool for Shiny and for Selecting Colours in Plots. https://CRAN.R-project.org/package=colourpicker.

———. 2018. Shinyjs: Easily Improve the User Experience of Your Shiny Apps in Seconds. https://CRAN.R-project.org/package=shinyjs.

Bache, Stefan Milton, and Hadley Wickham. 2014. magrittr: A Forward-Pipe Operator for R. https://CRAN.R-project.org/package=magrittr.

Bailey, Eric. 2015. ShinyBS: Twitter Bootstrap Components for Shiny. https://CRAN.R-project.org/package=shinyBS.

Bivand, Roger, Tim Keitt, and Barry Rowlingson. 2020. Rgdal: Bindings for the ’Geospatial’ Data Abstraction Library. https://CRAN.R-project.org/package=rgdal.

Bivand, Roger, and Colin Rundel. 2020. Rgeos: Interface to Geometry Engine - Open Source (’Geos’). https://CRAN.R-project.org/package=rgeos.

Bivand, Roger S., Edzer Pebesma, and Virgilio Gomez-Rubio. 2013. Applied Spatial Data Analysis with R, Second Edition. Springer, NY. https://asdar-book.org/.

Chambers, John M. 2008. Software for Data Analysis, Programming with R. Edited by Springer. https://doi.org/10.1007/978-0-387-75936-4.

Chang, Winston. 2018. Shinythemes: Themes for Shiny. https://CRAN.R-project.org/package=shinythemes.

Chang, Winston, and Barbara Borges Ribeiro. 2018. Shinydashboard: Create Dashboards with ’Shiny’. https://CRAN.R-project.org/package=shinydashboard.

Chang, Winston, Joe Cheng, JJ Allaire, Yihui Xie, and Jonathan McPherson. 2017. shiny: Web Application Framework for R. https://CRAN.R-project.org/package=shiny.

Charif, D., and J. R. Lobry. 2007. “SeqinR 1.0-2: A Contributed Package to the R Project for Statistical Computing Devoted to Biological Sequences Retrieval and Analysis.” In Structural Approaches to Sequence Evolution: Molecules, Networks, Populations, edited by U. Bastolla, M. Porto, H. E. Roman, and M. Vendruscolo, 207–32. Biological and Medical Physics, Biomedical Engineering. New York: Springer Verlag.

Cheng, Joe, and Tal Galili. 2018. D3heatmap: Interactive Heat Maps Using ’Htmlwidgets’ and ’D3.js’. https://CRAN.R-project.org/package=d3heatmap.

Cheng, Joe, Bhaskar Karambelkar, and Yihui Xie. 2018. Leaflet: Create Interactive Web Maps with the Javascript ’Leaflet’ Library. https://CRAN.R-project.org/package=leaflet.

Couture-Beil, Alex. 2018. Rjson: JSON for R. https://CRAN.R-project.org/package=rjson.

Crawley, Michael J. 2013. The R Book. Edited by Wiley. https://doi.org/10.1002/9781118448908.

Csardi, Gabor, and Tamas Nepusz. 2006. “The Igraph Software Package for Complex Network Research.” InterJournal Complex Systems: 1695. http://igraph.org.

Gagolewski, Marek. 2017. R package stringi: Character string processing facilities. http://www.gagolewski.com/software/stringi/.

Giraud, Timothée, and Nicolas Lambert. 2017. “Reproducible Cartography.” In Advances in Cartography and Giscience. ICACI 2017. Lecture Notes in Geoinformation and Cartography., edited by Michael Peterson, 173–83. Cham, Switzerland: Springer. https://doi.org/10.1007/978-3-319-57336-6_13.

———. 2016. “Cartography: Create and Integrate Maps in Your R Workflow.” JOSS 1 (4). https://doi.org/10.21105/joss.00054.

GmbH, Mirai Solutions, Martin Studer, The Apache Software Foundation, and Graph Builder. 2018. XLConnect: Excel Connector for R. https://CRAN.R-project.org/package=XLConnect.

Kane, Michael J., John Emerson, and Stephen Weston. 2013. “Scalable Strategies for Computing with Massive Data.” Journal of Statistical Software 55 (14): 1–19. http://www.jstatsoft.org/v55/i14/.

Lang, Duncan Temple, and the CRAN Team. 2019. XML: Tools for Parsing and Generating Xml Within R and S-Plus. https://CRAN.R-project.org/package=XML.

Lewis, B. W. 2017. Threejs: Interactive 3D Scatter Plots, Networks and Globes. https://CRAN.R-project.org/package=threejs.

Murrell, Paul. 2011. R Graphics. Edited by Chapman & Hall. https://www.stat.auckland.ac.nz/~paul/RG2e/.

Neuwirth, Erich. 2014. RColorBrewer: ColorBrewer Palettes. https://CRAN.R-project.org/package=RColorBrewer.

Paradis, E., and K. Schliep. 2019. “Ape 5.0: An Environment for Modern Phylogenetics and Evolutionary Analyses in R.” Bioinformatics 35: 526–28.

Pebesma, Edzer J., and Roger S. Bivand. 2005. “Classes and Methods for Spatial Data in R.” R News 5 (2): 9–13. https://CRAN.R-project.org/doc/Rnews/.

Perrier, Victor, Fanny Meyer, and David Granjon. 2019. ShinyWidgets: Custom Inputs Widgets for Shiny. https://CRAN.R-project.org/package=shinyWidgets.

Ram, Karthik, and Hadley Wickham. 2018. Wesanderson: A Wes Anderson Palette Generator. https://CRAN.R-project.org/package=wesanderson.

R Core Team. 2017. foreign: Read Data Stored by Minitab, S, SAS, SPSS, Stata, Systat, Weka, dBase, ... https://CRAN.R-project.org/package=foreign.

———. 2018a. R: A Language and Environment for Statistical Computing. Vienna, Austria: R Foundation for Statistical Computing. https://www.R-project.org/.

———. 2018b. Writing R Extensions. https://cran.r-project.org/doc/manuals/r-release/R-exts.html.

Sali, Andras. 2017. Shinycssloaders: Add Css Loading Animations to ’Shiny’ Outputs. https://CRAN.R-project.org/package=shinycssloaders.

Sarkar, Deepayan. 2008. Lattice, Multivariate Data Visualisation with R. Edited by Springer. https://doi.org/10.1007/978-0-387-75969-2.

Sievert, Carson. 2018. Plotly for R. https://plotly-r.com.

Thieurmel, Benoit, Antanas Marcelionis, Jeffery Petit, Elena Salette, and Titouan Robert. 2019. RAmCharts: JavaScript Charts Tool. https://CRAN.R-project.org/package=rAmCharts.

Tidière, Morgane, Xavier Thevenot, Adamantia Deligiannopoulou, Guillaume Douay, Mylisa Whipple, Aurélie Siberchicot, Jean-Michel Gaillard, and Jean-François Lemaître. 2018. “Maternal Reproductive Senescence Shapes the Fitness Consequences of the Parental Age Difference in Ruffed Lemurs.” Proceedings of the Royal Society B: Biological Sciences 285 (1886). https://doi.org/10.1098/rspb.2018.1479.

Vaidyanathan, Ramnath, Yihui Xie, JJ Allaire, Joe Cheng, and Kenton Russell. 2018. htmlwidgets: HTML Widgets for R. https://CRAN.R-project.org/package=htmlwidgets.

Vanderkam, Dan, JJ Allaire, Jonathan Owen, Daniel Gromer, and Benoit Thieurmel. 2018. Dygraphs: Interface to ’Dygraphs’ Interactive Time Series Charting Library. https://CRAN.R-project.org/package=dygraphs.

Whipple, M. 2014. “International Studbook for Ruffed Lemurs.”

———. 2016. “International and North American Regional Studbooks for Ruffed Lemurs.”

Wickham, Hadley. 2011. “The Split-Apply-Combine Strategy for Data Analysis.” Journal of Statistical Software 40 (1): 1–29. http://www.jstatsoft.org/v40/i01/.

———. 2015a. Advanced R. Edited by Chapman & Hall. http://adv-r.had.co.nz/.

———. 2015b. R Packages. Edited by O’Reilly. http://r-pkgs.had.co.nz/.

———. 2016. ggplot2, Elegant Graphics for Data Analysis. Edited by Springer. http://ggplot2.org/.

———. 2018. stringr: Simple, Consistent Wrappers for Common String Operations. https://CRAN.R-project.org/package=stringr.

Wickham, Hadley, and Jennifer Bryan. 2019. Readxl: Read Excel Files. https://CRAN.R-project.org/package=readxl.

Wickham, Hadley, Romain Francois, Lionel Henry, and Kirill Müller. 2017. Dplyr: A Grammar of Data Manipulation. https://CRAN.R-project.org/package=dplyr.

Wickham, Hadley, and Lionel Henry. 2018. tidyr: Easily Tidy Data with ’spread()’ and ’gather()’ Functions. https://CRAN.R-project.org/package=tidyr.

Wickham, Hadley, Jim Hester, and Romain Francois. 2018. Readr: Read Rectangular Text Data. https://CRAN.R-project.org/package=readr.

Wilkinson, Shaun P., and Simon K. Davy. 2018. phylogram: An R Package for Phylogenetic Analysis with Nested Lists. Journal of Open Source Software. Vol. 3. https://doi.org/10.21105/joss.00790.

Xiao, Nan. 2018. Ggsci: Scientific Journal and Sci-Fi Themed Color Palettes for ’Ggplot2’. https://CRAN.R-project.org/package=ggsci.

Xie, Yihui, Joe Cheng, and Xianying Tan. 2019. DT: A Wrapper of the Javascript Library ’Datatables’. https://CRAN.R-project.org/package=DT.

Yu, Guangchuang. 2020. “Using Ggtree to Visualize Data on Tree-Like Structures.” Current Protocols in Bioinformatics 69 (1): e96. https://doi.org/10.1002/cpbi.96.

Yu, Guangchuang, Tommy Tsan-Yuk Lam, Huachen Zhu, and Yi Guan. 2018. “Two Methods for Mapping and Visualizing Associated Data on Phylogeny Using Ggtree.” Molecular Biology and Evolution 35 (2): 3041–3. https://doi.org/10.1093/molbev/msy194.

Yu, Guangchuang, David Smith, Huachen Zhu, Yi Guan, and Tommy Tsan-Yuk Lam. 2017. “Ggtree: An R Package for Visualization and Annotation of Phylogenetic Trees with Their Covariates and Other Associated Data.” Methods in Ecology and Evolution 8 (1): 28–36. https://doi.org/10.1111/2041-210X.12628.